Summary

Adds two new output modes to the serializer, both purely additive — existing jsonToHtml / htmlToJson / jsonToMarkdown are untouched.

1. jsonToHtmlAsync — async variant of jsonToHtml where handlers can return Promise<string>
2. toTree<T>() — generic, framework-agnostic tree walker that outputs any type T
3. /react entry point — reference implementation of toTree<ReactNode>() with default handlers (see discussion below)

jsonToHtmlAsync

Async version of toRedactor. Children are resolved concurrently via Promise.all. Handler results are awaited, so both sync and async return values work. No changes to existing jsonToHtml.

toTree<T>() — generic tree walker

A framework-agnostic tree walker in src/toTree.ts (~120 lines, zero dependencies). Accepts IJsonToTreeOptions<T>:

interface IJsonToTreeOptions<T> {
  elementTypes: Record<string, (jsonBlock: any, children: T | null) => T>
  textMarks?: Record<string, (children: T, value?: any) => T>
  createText: (text: string) => T
  createLineBreak: (key: string) => T
  combineChildren: (children: T[]) => T
  wrapTextAttrs?: (node: T, attrs: { classname?: string; id?: string }) => T
  wrapTextStyle?: (node: T, style: { color?: string; fontFamily?: string; fontSize?: string }) => T
  keyElement?: (element: T, key: string) => T
}

The walker handles recursion, text processing, and mark application. The caller provides all construction logic for their chosen output format.

/react entry point — discussion

This PR includes src/react.tsx, shipped as a separate entry point at @contentstack/json-rte-serializer/react. It provides:

• reactPrimitives — createText, createLineBreak, combineChildren, wrapTextAttrs, wrapTextStyle, keyElement
• defaultElementTypes — handlers for all standard element types (p, h1–h6, a, img, tables, grid, etc.)
• defaultTextMarks — bold→<strong>, italic→<em>, etc.
• jsonToReact() — convenience wrapper that combines everything

React is an optional peer dependency and is externalized from the bundle. Non-React consumers never touch this entry point.

Question for maintainers

Should /react live in this repo, or should it be maintained externally?

Arguments for including it:

• Without it, every React consumer has to implement the same ~30 default element handlers + 6 primitive callbacks — real boilerplate that's identical across projects
• It's a natural complement to toTree<T>() — the generic API is only useful if there are reference implementations
• Separate exports entry point means it's fully tree-shakeable and non-React consumers never see it
• React is already in devDependencies (for the .tsx build)

Arguments for keeping it external:

• Adds a framework opinion to a framework-agnostic library
• Maintainers would need to update it when new element types are added
• Could set a precedent (Vue adapter? Svelte adapter?)

Happy to split this PR and keep only jsonToHtmlAsync + toTree<T>() if you'd prefer /react to live elsewhere. The included implementation serves as documentation either way — it shows exactly how to wire up toTree for a virtual DOM framework.

What's NOT changed

• jsonToHtml / toRedactor — untouched
• htmlToJson / fromRedactor — untouched
• jsonToMarkdown — untouched
• All 127 existing tests pass
• No breaking changes

Package structure

@contentstack/json-rte-serializer
├── index.js    — jsonToHtml, jsonToHtmlAsync, htmlToJson, jsonToMarkdown, toTree
└── react.js    — jsonToReact, reactPrimitives, defaultElementTypes, defaultTextMarks